// 获取url参数
export function getUrlParams(url: string, key: string): string | null {
  try {
    const urlObj = new URL(url)
    return urlObj.searchParams.get(key)
  } catch (error) {
    // 如果URL格式不正确，尝试直接解析查询字符串
    const queryString = url.includes('?') ? url.split('?')[1] : url
    const params = new URLSearchParams(queryString)
    return params.get(key)
  }
}

// example: house_id=1&scene_id=2&tag_id=3
export function parseTagKeyBord(data: string, splitFlag: string = '&') {
  if (!data) return data

  const params = data.split(splitFlag)

  const result: Record<string, string> = {}

  params.forEach((param) => {
    const [key, value] = param.split('=')

    if (!key) return

    result[key] = value
  })

  return result
}

export function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms))
}

/**
 * 带重试机制的请求函数
 * @param requestFn 要执行的请求函数，必须返回Promise
 * @param timeout 超时时间，默认3000ms
 * @param maxRetries 最大重试次数，默认5次
 * @returns Promise<T> 返回请求结果
 */
export async function retryRequest<T>(
  requestFn: () => Promise<T>,
  timeout: number = 3000,
  maxRetries: number = 5
): Promise<T> {
  let lastError: Error | null = null

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      // 创建超时Promise
      const timeoutPromise = new Promise<never>((_, reject) => {
        setTimeout(() => {
          reject(new Error(`Request timeout after ${timeout}ms`))
        }, timeout)
      })

      // 执行请求并设置超时
      const result = await Promise.race([requestFn(), timeoutPromise])

      // 如果成功获取到结果，直接返回
      return result
    } catch (error) {
      lastError = error instanceof Error ? error : new Error(String(error))

      // 如果是最后一次尝试，抛出错误
      if (attempt === maxRetries) {
        console.error(`Request failed after ${maxRetries + 1} attempts:`, lastError.message)
        throw lastError
      }

      // 打印重试信息
      console.warn(`Request attempt ${attempt + 1} failed, retrying... Error: ${lastError.message}`)

      // 等待一段时间再重试（可选的退避策略）
      await sleep(1000 * (attempt + 1)) // 递增延迟：1s, 2s, 3s, 4s, 5s
    }
  }

  // 理论上不会执行到这里，但为了类型安全
  throw lastError || new Error('Unknown error')
}

/**
 * 简化版重试请求函数，使用默认参数
 * @param requestFn 要执行的请求函数
 * @returns Promise<T> 返回请求结果
 */
export async function retry<T>(requestFn: () => Promise<T>): Promise<T> {
  return retryRequest(requestFn)
}

/**
 * 对象转成queryString
 */
export function objectToQueryString(obj: Record<string, string>) {
  return Object.entries(obj)
    .map(([key, value]) => `${key}=${value}`)
    .join('&')
}
